import { Customer } from '../types';
import { customerDb } from './dbService';

// 服务器地址 - 修改为本地代理服务器
const API_BASE_URL = 'http://localhost:3001';

// 模拟客户数据，实际中可以从后端API获取
const mockCustomers: Customer[] = [
  {
    id: '1',
    name: '张三公司',
    address: '上海市浦东新区张杨路500号',
    phone: '13812345678',
    visitDuration: 60
  },
  {
    id: '2',
    name: '李四企业',
    address: '上海市徐汇区漕宝路100号',
    phone: '13987654321',
    visitDuration: 45
  },
  {
    id: '3',
    name: '王五工厂',
    address: '上海市嘉定区曹安公路1800号',
    phone: '13612345678',
    visitDuration: 90
  },
  {
    id: '4',
    name: '赵六商店',
    address: '上海市静安区南京西路1788号',
    phone: '13512345678',
    visitDuration: 30
  },
  {
    id: '5',
    name: '钱七事务所',
    address: '上海市黄浦区人民大道100号',
    phone: '15812345678',
    visitDuration: 60
  }
];

// 本地存储键名
const CUSTOMERS_STORAGE_KEY = 'route_planner_customers';

// 从本地存储获取客户数据
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const getCustomersFromStorage = (): Customer[] => {
  const storedData = localStorage.getItem(CUSTOMERS_STORAGE_KEY);
  if (storedData) {
    try {
      return JSON.parse(storedData);
    } catch (e) {
      console.error('Failed to parse customers data', e);
    }
  }
  // 如果没有存储数据或解析失败，返回模拟数据
  return mockCustomers;
};

// 保存客户数据到本地存储
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const saveCustomersToStorage = (customers: Customer[]): void => {
  localStorage.setItem(CUSTOMERS_STORAGE_KEY, JSON.stringify(customers));
};

// 获取所有客户
export const getAllCustomers = async (): Promise<Customer[]> => {
  try {
    // 每次直接从数据库获取客户数据，不使用缓存
    console.log('从数据库获取客户数据');
    return await customerDb.getAllCustomers();
  } catch (error) {
    console.error('获取客户数据失败:', error);
    // 出错时返回空数组
    return [];
  }
};

// 添加客户
export const addCustomer = async (customer: Omit<Customer, 'id'>): Promise<Customer> => {
  try {
    // 添加客户到数据库
    const newCustomer = await customerDb.addCustomer(customer);
    return newCustomer;
  } catch (error) {
    console.error('添加客户失败:', error);
    throw error;
  }
};

// 更新客户
export const updateCustomer = async (updatedCustomer: Customer): Promise<Customer | null> => {
  try {
    // 更新数据库中的客户
    return await customerDb.updateCustomer(updatedCustomer);
  } catch (error) {
    console.error('更新客户失败:', error);
    return null;
  }
};

// 删除客户
export const deleteCustomer = async (id: string): Promise<boolean> => {
  try {
    // 从数据库删除客户
    return await customerDb.deleteCustomer(id);
  } catch (error) {
    console.error('删除客户失败:', error);
    return false;
  }
};

// 通过地址获取客户地理位置坐标（使用高德地图API）
export const getCustomerCoordinates = async (customer: Customer): Promise<Customer> => {
  if (customer.location) {
    console.log(`客户 ${customer.name} 已有坐标，无需重新获取`);
    return customer; // 如果已有坐标，直接返回
  }
  
  console.log(`尝试获取客户 ${customer.name} 的坐标，地址: ${customer.address}`);
  
  try {
    // 设置超时时间和更快的超时检测
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 15000); // 缩短为15秒超时
    
    // 构建请求URL，确保地址正确编码
    const encodedAddress = encodeURIComponent(customer.address);
    const requestUrl = `${API_BASE_URL}/amap/maps/geo?address=${encodedAddress}`;
    console.log(`发起请求: ${requestUrl}`);
    
    // 使用本地代理服务器
    const response = await fetch(requestUrl, {
      signal: controller.signal,
      method: 'GET', // 明确指定GET方法
      headers: {
        'Accept': 'application/json',
        'Cache-Control': 'no-cache' // 避免缓存问题
      }
    }).catch(error => {
      console.error('请求发送失败:', error);
      throw new Error('网络请求失败，请检查网络连接');
    });
    
    // 清除超时计时器
    clearTimeout(timeoutId);
    
    // 检查响应状态
    if (!response.ok) {
      console.error(`API响应错误，状态码: ${response.status}`);
      throw new Error(`API请求失败，状态码: ${response.status}`);
    }
    
    // 检查响应类型并解析
    const contentType = response.headers.get('content-type');
    if (!contentType || !contentType.includes('application/json')) {
      const responseText = await response.text();
      console.error(`响应不是JSON格式: ${contentType}`);
      console.error('响应内容:', responseText);
      throw new Error('服务器返回了非JSON格式的响应');
    }
    
    // 解析响应数据
    const data = await response.json();
    console.log('地址解析结果:', data);
    
    // 处理正常的API响应
    if (data.status === '1' && data.geocodes && data.geocodes.length > 0) {
      const location = data.geocodes[0].location.split(',');
      const updatedCustomer = {
        ...customer,
        location: {
          longitude: parseFloat(location[0]),
          latitude: parseFloat(location[1])
        }
      };
      
      // 更新客户数据中的坐标
      console.log(`成功获取客户 "${customer.name}" 的坐标:`, updatedCustomer.location);
      await updateCustomer(updatedCustomer);
      return updatedCustomer;
    }
    
    // 使用环境判断，统一入口生成模拟数据
    if (process.env.NODE_ENV === 'development') {
      console.warn('API无结果，使用模拟坐标用于开发测试');
      return await generateMockCustomerLocation(customer);
    }
    
    throw new Error(`地址解析失败：${data.info || '无法获取地理坐标'}`);
  } catch (error) {
    console.error('获取客户坐标失败:', error);
    
    // 开发环境下使用模拟数据
    if (process.env.NODE_ENV === 'development') {
      console.warn('出错时使用模拟坐标用于开发测试');
      return await generateMockCustomerLocation(customer);
    }
    
    // 返回原始客户数据，保留错误信息
    throw error;
  }
};

// 辅助函数：生成模拟客户坐标数据
async function generateMockCustomerLocation(customer: Customer): Promise<Customer> {
  // 为客户生成随机坐标，在上海市区范围内
  const mockCustomer = {
    ...customer,
    location: {
      longitude: 121.47 + (Math.random() - 0.5) * 0.1,
      latitude: 31.23 + (Math.random() - 0.5) * 0.1
    }
  };
  
  console.log(`为客户 "${customer.name}" 生成模拟坐标:`, mockCustomer.location);
  
  // 保存到数据库
  await updateCustomer(mockCustomer);
  return mockCustomer;
}